home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 21 / Cream of the Crop 21 (Terry Blount) (October 1996).iso / os2 / vsoup11.zip / mts.cc < prev    next >
C/C++ Source or Header  |  1996-09-02  |  6KB  |  386 lines
  1. //  $Id: mts.cc 1.6 1996/09/02 13:23:12 hardy Exp $
  2. //
  3. //  This progam/module was written by Hardy Griech based on ideas and
  4. //  pieces of code from Chin Huang (cthuang@io.org).  Bug reports should
  5. //  be submitted to rgriech@ibm.net.
  6. //
  7. //  This file is part of soup++ for OS/2.  Soup++ including this file
  8. //  is freeware.  There is no warranty of any kind implied.  The terms
  9. //  of the GNU Gernal Public Licence are valid for this piece of software.
  10. //
  11.  
  12.  
  13. #include <io.h>
  14. #include <stdarg.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include "mts.hh"
  20. #include "sema.hh"
  21.  
  22.  
  23.  
  24. TSemaphor sysSema;
  25. static TSemaphor regSema;
  26.  
  27.  
  28.  
  29. FILE *fopenT( const char *name, const char *mode )
  30. {
  31.     FILE *res;
  32.  
  33.     sysSema.Request();
  34.     res = fopen( name,mode );
  35.     sysSema.Release();
  36.     return res;
  37. }   // fopenT
  38.  
  39.  
  40.  
  41. int fcloseT( FILE *io )
  42. {
  43.     int res;
  44.  
  45.     sysSema.Request();
  46.     res = fclose( io );
  47.     sysSema.Release();
  48.     return res;
  49. }   // fcloseT
  50.  
  51.  
  52.  
  53. int fflushT( FILE *out )
  54. {
  55.     int res;
  56.  
  57.     sysSema.Request();
  58.     res = fflush( out );
  59.     sysSema.Release();
  60.     return res;
  61. }   // fflushT
  62.  
  63.  
  64.  
  65. int fprintfT( FILE *out, const char *fmt, ... )
  66. {
  67.     va_list ap;
  68.     char buf[BUFSIZ];
  69.     int  buflen;
  70.  
  71.     sysSema.Request();
  72.  
  73.     va_start( ap, fmt );
  74.     buflen = vsprintf( buf, fmt, ap );
  75.     va_end( ap );
  76.     if (buflen > 0)
  77.     fputs( buf, out );
  78.     
  79.     sysSema.Release();
  80.     return buflen;
  81. }   // fprintfT
  82.  
  83.  
  84.  
  85. int printfT( const char *fmt, ... )
  86. {
  87.     va_list ap;
  88.     char buf[BUFSIZ];
  89.     int  buflen;
  90.  
  91.     sysSema.Request();
  92.  
  93.     va_start( ap, fmt );
  94.     buflen = vsprintf( buf, fmt, ap );
  95.     va_end( ap );
  96.     if (buflen > 0)
  97.     fputs( buf, stdout );
  98.     
  99.     sysSema.Release();
  100.     return buflen;
  101. }   // printfT
  102.  
  103.  
  104.  
  105. int sprintfT( char *dst, const char *fmt, ... )
  106. {
  107.     va_list ap;
  108.     char buf[BUFSIZ];
  109.     int  buflen;
  110.  
  111.     sysSema.Request();
  112.  
  113.     va_start( ap, fmt );
  114.     buflen = vsprintf( buf, fmt, ap );
  115.     va_end( ap );
  116.     if (buflen >= 0)
  117.     memcpy( dst,buf,buflen+1 );
  118.     
  119.     sysSema.Release();
  120.     return buflen;
  121. }   // sprintfT
  122.  
  123.  
  124.  
  125. int vfprintfT( FILE *out, const char *fmt, va_list arg_ptr )
  126. {
  127.     int buflen;
  128.  
  129.     sysSema.Request();
  130.     buflen = vfprintf( out,fmt,arg_ptr );
  131.     sysSema.Release();
  132.     return buflen;
  133. }   // vfprintfT
  134.  
  135.  
  136.  
  137. int vprintfT( const char *fmt, va_list arg_ptr )
  138. {
  139.     int buflen;
  140.  
  141.     sysSema.Request();
  142.     buflen = vprintf( fmt,arg_ptr );
  143.     sysSema.Release();
  144.     return buflen;
  145. }   // vprintfT
  146.  
  147.  
  148.  
  149. int vsprintfT( char *dst, const char *fmt, va_list arg_ptr )
  150. {
  151.     int buflen;
  152.  
  153.     sysSema.Request();
  154.     buflen = vsprintf( dst,fmt,arg_ptr );
  155.     sysSema.Release();
  156.     return buflen;
  157. }   // vsprintfT
  158.  
  159.  
  160.  
  161. int sscanfT( const char *src, const char *fmt, ... )
  162. {
  163.     va_list ap;
  164.     int fields;
  165.  
  166.     sysSema.Request();
  167.     va_start( ap, fmt );
  168.     fields = vsscanf( src, fmt, ap );
  169.     va_end( ap );
  170.     sysSema.Release();
  171.     return fields;
  172. }   // sscanfT
  173.  
  174.  
  175.  
  176. int fscanfT( FILE *in, const char *fmt, ... )
  177. {
  178.     va_list ap;
  179.     int fields;
  180.  
  181.     sysSema.Request();
  182.     va_start( ap, fmt );
  183.     fields = vfscanf( in, fmt, ap );
  184.     va_end( ap );
  185.     sysSema.Release();
  186.     return fields;
  187. }   // fscanfT
  188.  
  189.  
  190.  
  191. int fgetcT( FILE *in )
  192. {
  193.     int res;
  194.  
  195.     sysSema.Request();
  196.     res = fgetc( in );
  197.     sysSema.Release();
  198.     return res;
  199. }   // fgetcT
  200.  
  201.  
  202.  
  203. char *fgetsT( char *buf, int len, FILE *in )
  204. {
  205.     char *res;
  206.  
  207.     sysSema.Request();
  208.     res = fgets( buf,len,in );
  209.     sysSema.Release();
  210.     return res;
  211. }   // fgetsT
  212.  
  213.  
  214.  
  215. int fputcT( int c, FILE *out )
  216. {
  217.     int res;
  218.  
  219.     sysSema.Request();
  220.     res = fputc( c,out );
  221.     sysSema.Release();
  222.     return res;
  223. }   // fputcT
  224.  
  225.  
  226.  
  227. int fputsT( const char *s, FILE *out )
  228. {
  229.     int res;
  230.  
  231.     sysSema.Request();
  232.     res = fputs( s,out );
  233.     sysSema.Release();
  234.     return res;
  235. }   // fputsT
  236.  
  237.  
  238.  
  239. size_t freadT( void *buf, size_t size, size_t count, FILE *in )
  240. {
  241.     size_t res;
  242.  
  243.     sysSema.Request();
  244.     res = fread( buf,size,count,in );
  245.     sysSema.Release();
  246.     return res;
  247. }   // freadT
  248.  
  249.  
  250.  
  251. size_t fwriteT( const void *buf, size_t size, size_t count, FILE *out )
  252. {
  253.     size_t res;
  254.  
  255.     sysSema.Request();
  256.     res = fwrite( buf,size,count,out );
  257.     sysSema.Release();
  258.     return res;
  259. }   // fwriteT
  260.  
  261.  
  262.  
  263. int fseekT( FILE *io, long offset, int origin )
  264. {
  265.     int res;
  266.  
  267.     sysSema.Request();
  268.     res = fseek( io,offset,origin );
  269.     sysSema.Release();
  270.     return res;
  271. }   // fseekT
  272.  
  273.  
  274.  
  275. long ftellT( FILE *io )
  276. {
  277.     long res;
  278.  
  279.     sysSema.Request();
  280.     res = ftell( io );
  281.     sysSema.Release();
  282.     return res;
  283. }   // ftellT
  284.  
  285.  
  286.  
  287. int ftruncateT( FILE *io, long offset )
  288. {
  289.     int handle;
  290.     int res;
  291.  
  292.     sysSema.Request();
  293.     handle = fileno(io);
  294.     res = ftruncate( handle,offset );
  295.     fseek( io,offset,SEEK_SET );
  296.     sysSema.Release();
  297.     return res;
  298. }   // ftruncateT
  299.  
  300.  
  301.  
  302. FILE *popenT( const char *command, const char *mode )
  303. {
  304.     FILE *res;
  305.  
  306.     sysSema.Request();
  307.     res = popen( command,mode );
  308.     sysSema.Release();
  309.     return res;
  310. }   // popenT
  311.  
  312.  
  313. int pcloseT( FILE *io )
  314. {
  315.     int res;
  316.  
  317.     sysSema.Request();
  318.     res = pclose( io );
  319.     sysSema.Release();
  320.     return res;
  321. }   // pcloseT
  322.  
  323.  
  324.  
  325. int removeT( const char *fname )
  326. {
  327.     int res;
  328.  
  329.     sysSema.Request();
  330.     res = remove( fname );
  331.     sysSema.Release();
  332.     return res;
  333. }   // removeT
  334.  
  335.  
  336.  
  337. regexp *regcompT( const char *exp )
  338. {
  339.     regexp *res;
  340.  
  341.     regSema.Request();
  342.     res = regcomp( exp );
  343.     regSema.Release();
  344.     return res;
  345. }   // regcompT
  346.  
  347.  
  348.  
  349. int regexecT( const regexp *cexp, const char *target )
  350. {
  351.     int res;
  352.  
  353.     regSema.Request();
  354.     res = regexec( cexp,target );
  355.     regSema.Release();
  356.     return res;
  357. }   // regexecT
  358.  
  359.  
  360.  
  361. const char *xstrdup( const char *src )
  362. {
  363.     int len;
  364.     char *dst;
  365.  
  366.     len = strlen(src)+1;
  367.     dst = new char [len];
  368.     if (dst != NULL)
  369.     memcpy( dst,src,len );
  370.     else {
  371.     fprintfT( stderr,"\nxstrdup failed\nprogram aborted\n" );
  372.     exit( 3 );
  373.     }
  374.     return dst;
  375. }   // xstrdup
  376.  
  377.  
  378.  
  379. void xstrdup( const char **dst, const char *src )
  380. {
  381.     if (*dst != NULL)
  382.     delete *dst;
  383.  
  384.     *dst = xstrdup( src );
  385. }   // xstrdup
  386.